הוראות לנבחן סף ובהם שמונה שאלות. עליך לענות על שש שאלות, על פי ההנחיות בכל פרק. גמר לבתי ספר לטכנאים ולהנדסאים

Transcription

1 גמר לבתי ספר לטכנאים ולהנדסאים סוג הבחינה: מדינת ישראל אביב תשע"ג, 2013 מועד הבחינה: משרד החינוך סמל השאלון: תכנות מערכות בשפת C ושפת סף הוראות לנבחן א. משך הבחינה: ארבע שעות. ב. מבנה השאלון ומפתח ההערכה: בשאלון זה שני נושאים: תכנות מערכות בשפת C ושפת סף ובהם שמונה שאלות. עליך לענות על שש שאלות, על פי ההנחיות בכל פרק. בשני הנושאים בסך הכול 100 נקודות. ג. חומר עזר מותר לשימוש: כל חומר עזר כתוב בכתב יד או מודפס על נייר. ההנחיות בשאלון זה מנוסחות בלשון זכר, אך מכוונות הן לנבחנות והן לנבחנים. בהצלחה! בשאלון זה 40 עמודים.

2 - 2 - השאלות נושא א': תכנות מערכות בשפת )50 C נקודות( פרק ראשון )35 נקודות( ענה על שתי השאלות 1 2. שאלה - 1 שאלת חובה )25 נקודות( מעוניינים לבנות מערכת ממוחשבת שתנהל מידע על שחקנים וקבוצות כדורגל בליגה הלאומית. כדי לנהל את המידע הוחלט להחזיק שתי רשימות מקושרות חד כיווניות: אחת בעבור קבוצות כדורגל, והשנייה בעבור שחקני כדורגל בליגה הלאומית. הנחות יסוד: 1. שחקן יכול להיות שייך לקבוצה אחת לכל היותר. 2. שחקן שלא שייך לאף קבוצה ייקרא "שחקן חופשי". 3. קבוצה ללא שחקנים תיקרא קבוצה לא פעילה". 4. בניהול המידע של המערכת הממוחשבת קבוצה עשויה לעבור למצב של "קבוצה לא פעילה". המשך בעמוד 2

3 - 3 - להלן הגדרות והכרזות של טיפוסי הנתונים במערכת הממוחשבת בשפת C התפות בכל סעיפי השאלה: typedef enum FAILURE,SUCCESS,INVALID_INPUT, DUPLICATE_RECORD,MISSING_RECORD statustype; typedef enumfalse,true boolean; טיפוס שחקן // playertype typedef struct long plyrid; int age; char firstname[15]; char lastname[20]; מספר הזהות // גיל // שם פרטי // שם משפחה // מצביע לצומת ברשימת הקבוצות, המייצג את הקבוצה שבה // *tmptr; struct teamtype משחק השחקן // שדה קישור, מצביע לצומת הבא המייצג שחקן *next;// struct playertype playerrec,*playerptr; typedef struct teamtype טיפוס הקבוצה // char teamname[20]; int num; playerptr *plarray; שם הקבוצה // מספר השחקנים בקבוצה // מערך דינאמי של שחקני קבוצה. כל תא במערך זה מצביע // לצומת המייצג שחקן ברשימה מקושרת חד כיוונית של השחקנים // שדה קישור, מצביע לצומת הבא המייצג קבוצה // *next; struct teamtype teamrec,*teamptr; המשך בעמוד 4

4 - 4 - להלן איור של מבנה הנתונים לניהול מידע: פרטי קבוצה 1 מערך שחקנים של קבוצה 1 (plarray).... מצביע לרשימת הקבוצות פרטי שחקן פרטי שחקן פרטי שחקן חופשי פרטי שחקן מצביע לרשימת שחקנים פרטי קבוצה 2 מערך ריק של שחקנים של קבוצה 2 שהיא לא פעילה כלומר plarray מצביע ל NULL.... פרטי קבוצה 3 מערך שחקנים של קבוצה 3 (plarray) המשך בעמוד 5

5 - 5 - נתונה ספריית פונקציות. הספרייה מכילה, בין היתר, את הפונקציות האלה: שם הפעולה statustype init (void) הוספת שחקן statustype insertplayer (long playerid,char lastname[], char firstname[],int age) מחיקת שחקן statustype deleteplayer (long playerid) הוספת קבוצה statustype insertteam (char name[]) מחיקת קבוצה statustype deleteteam (char teamname[]) הוספת שחקן לקבוצה statustype joinplayertoteam (long PlayerID,char team[]) תיעוד הפונקציה מאתחלת את המערכת הממוחשבת. הפונקציה מקבלת את פרטי השחקן. אם השחקן אינו מופיע במערכת הממוחשבת, אז הפונקציה מוסיפה אותו לראש הרשימה המקושרת של שחקנים ומחזירה את הערך ; SUCCESS ואם הוא כן מופיע אזי היא מחזירה את הערך. DUPLICATE_RECORD הפונקציה מקבלת את מספר הזהות של שחקן. אם השחקן מופיע ברשימת השחקנים, אז הפונקציה מוחקת אותו מן המערכת הממוחשבת ומחזירה את הערך ; SUCCESS אם הוא אינו מופיע, אזי היא מחזירה את הערך.MISSING_RECORD הפונקציה מקבלת את שם הקבוצה. אם הקבוצה אינה מופיעה ברשימת הקבוצות, אז היא מוסיפה אותה לראש רשימת הקבוצות ומחזירה את הערך ; SUCCESS אם היא מופיעה, אזי היא מחזירה את הערך.DUPLICATE_RECORD הפונקציה מקבלת את שם הקבוצה. אם הקבוצה מופיעה ברשימת הקבוצות, אז היא הופכת את כל שחקניה ל שחקנים חופשיים, מוחקת את הקבוצה מרשימת הקבוצות ומחזירה את הערך ; SUCCESS ואם היא אינה מופיעה, היא מחזירה את הערך.MISSING_RECORD הפונקציה מקבלת את מספר הזהות של שחקן ואת שם הקבוצה. אם השחקן מופיע ברשימת השחקנים והנו שחקן חופשי והקבוצה team מופיעה ברשימת הקבוצות, אז הפונקציה מוסיפה את השחקן הזה לקבוצה ומחזירה את הערך ; SUCCESS אם לא היא מחזירה את הערך.MISSING_RECORD המשך בעמוד 6

6 - 6 - הפונקציה מקבלת את מספר הזהות של שחקן. אם השחקן מופיע ברשימת השחקנים ושייך לאחת הקבוצות, אז היא מוחקת את השחקן מהקבוצה בה הוא משחק, כלומר הופכת אותו ל שחקן חופשי, ומחזירה את הערך, SUCCESS ואם הוא אינו מופיע, אזי היא מחזירה את הערך. MISSING_RECORD הפונקציה מדפיסה את פרטי כל שחקני הליגה הלאומית. הפונקציה מדפיסה את פרטי כל הקבוצות של הליגה הלאומית. הפונקציה מקבלת את שם הקבוצה. אם הקבוצה נמצאת ברשימת הקבוצות, אז היא מדפיסה את פרטי הקבוצה ואת פרטי כל שחקני הקבוצה ומחזירה את הערך, SUCCESS ואם הקבוצה אינה נמצאת ברשימה היא מחזירה את הערך. MISSING_RECORD הפונקציה מקבלת את head שהינו מצביע לראש רשימת קבוצות ואת פונקציות ההשוואה. compare הפונקציה ממיינת בסדר עולה את רשימת הקבוצות. הפונקציה מקבלת את מספר הזהות של שחקן. אם השחקן מופיע ברשימת השחקנים, אז היא מחזירה מצביע לצומת המייצג את השחקן הזה ; אם הוא אינו מופיע, אזי היא מחזירה את הערך. NULL הפונקציה מקבלת את שם הקבוצה. אם הקבוצה מופיעה ברשימת הקבוצות, אז היא מחזירה מצביע לצומת המייצג את הקבוצה הזו ; אם הוא אינו מופיע, אזי היא מחזירה את הערך. NULL מחיקת שחקן מקבוצה statustype deleteplayerfromteam (long playerid) הדפסת שחקנים בליגה void printplayers (void) הדפסת קבוצות בליגה void printteams (void) הדפסת פרטי קבוצה statustype printteamdetais (char team[]) teamptr mysort (teamptr head,int (*compare) (teamptr p,teamptr q)) איתור שחקן playerptr findplayer (long playerid) איתור קבוצה teamptr findteam (char name[]) המשך בעמוד 7

7 - 7 - בכל סעיף הנך רשאי להשתמש בכל הפונקציות שבטבלה שלעיל. להלן הגדרות בעבור משתנים גלובאליים: מצביע לראש רשימה מקושרת חד כיוונית של שחקנים בליגה הלאומית// players; playerptr teamptr teams; מצביע לראש רשימה מקושרת חד כיוונית של קבוצות בליגה הלאומית // א. לפניך פונקציה שכותרתה: statustype insertplayer(long playerid,char lastname[], char firstname[],int age) פונקציה זו מקבלת את פרטי השחקן: מספר הזהות של playerid, שם המשפחה - lastnam, השם הפרטי - firstname, והגיל - age. הפונקציה מוסיפה את השחקן הזה לראש רשימה מקושרת של השחקנים. הערה: פונקציה זו אינה מצרפת את השחקן לקבוצה כלשהי, כלומר השחקן יהיה "שחקן חופשי". הפונקציה מחזירה את הערך מטיפוס, statustype כמפורט בטבלה שלהלן: אם שחקן בעל מספר זהות playerid קיים ברשימת השחקנים. אם שחקן בעל מספר זהות playerid נוסף לרשימת השחקנים. DUPLICATE_RECORD SUCCESS המשך בעמוד 8

8 - 8 - בפונקציה חסרים חמישה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (5), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. statustype insertplayer(long playerid,char lastname[], char firstname[],int age) statustype status = (1) ; playerptr p,q; q = (2) ; if(q) status = DUPLICATE_RECORD; return status; p = malloc(sizeof(playerrec)); p -> plyrid = playerid; strcpy(p->firstname,firstname); strcpy(p->lastname,lastname); p -> age = age; שחקן חופשי // = (3) ; tmptr p -> (4) = players; (5) = p; return status; המשך בעמוד 9

9 - 9 - ב. לפניך פונקציה שכותרתה: statustype deleteplayerfromteam(long playerid) פונקציה זו מקבלת את מספר הזהות של שחקן playerid. אם השחקן מופיע ברשימת השחקנים, אז היא מוחקת את השחקן מהקבוצה שבה הוא משחק, כלומר הופכת אותו ל "שחקן חופשי", ומחזירה את הערך. SUCCESS אם לא היא מחזירה את הערך. MISSING_RECORD הערה: הפונקציה הזו אינה מוחקת את השחקן מרשימת השחקנים. הפונקציה מחזירה את הערך מטיפוס, statustype כמפורט בטבלה שלהלן: אם שחקן בעל מספר זהות playerid לא קיים ברשימת השחקנים או אם השחקן הוא שחקן חופשי. אם שחקן בעל מספר זהות playerid אינו שחקן חופשי. MISSING_RECORD SUCCESS להלן תהליך למחיקת שחקן מהקבוצה: מאתרים את השחקן במערך שחקני קבוצתו ומציבים את מיקומו במערך הזה במשתנה. k ערך שנמצא בתא שמיקומו 1+ i יועתק לתא i לכל, 1+k i < num כאשר num מציין את מספר השחקנים בקבוצה זו. מעדכנים את מספר השחקנים בקבוצה זו. מקצים מערך דינמי חדש של שחקני קבוצה זו כאשר גודל המערך החדש הוא כמספר השחקנים בקבוצה בשלב זה. בפונקציה חסרים ארבעה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (4), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. המשך בעמוד 10

10 statustype deleteplayerfromteam(long playerid) playerptr p; teamptr t; int i,k; statustype status = SUCCESS; p = (1) ; if((p==null) (p->tmptr==null))status= MISSING_RECORD; else t = p->tmptr; p->tmptr = NULL; for(i=0;i< (2) ; i++) if ( (3) == playerid) k = i; break; for(i=k+1;i< (2) ; i++) t -> plarray[i-1] = t->plarray[i]; t->num = t->num - 1; t->plarray=realloc(t->plarray, (4) ); return status; המשך בעמוד 11

11 ג. לפניך פונקציה שכותרתה: statustype deleteplayer(long playerid) פונקציה זו מקבלת את מספר הזהות של שחקן. playerid אם השחקן מופיע ברשימת השחקנים )כשחקן חופשי או כשחקן שאינו חופשי(, אז הפונקציה מוחקת אותו מן המערכת הממוחשבת. הפונקציה הזו מחזירה את הערך מטיפוס statustype כמפורט בטבלה שלהלן: אם שחקן בעל מספר זהות playerid אינו קיים ברשימת שחקנים. אם שחקן בעל מספר זהות playerid קיים ברשימת השחקנים. MISSING_RECORD SUCCESS בפונקציה חסרים חמישה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (5), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. המשך בעמוד 12

12 statustype deleteplayer(long playerid) playerptr p,q; statustype status= (1) ; p = findplayer(playerid); if(p==null) status = MISSING_RECORD; else if (p->tmptr) status = (2) ; q = players; if ( (3) ) players = q->next; free (p); else while (q->next) if (q->next == p) q->next = (4) ; (5) ; break; q = q->next; return status; המשך בעמוד 13

13 ד. לפניך פונקציה שכותרתה: statustype deleteteam(char teamname[]) פונקציה זו מקבלת את שם הקבוצה -.teamname אם הקבוצה נמצאת ברשימת הקבוצות, אז הפונקציה הופכת את כל שחקניה ל"שחקנים חופשיים" )ראה הנחת יסוד 2(, ומוחקת את הקבוצה הזו מרשימת הקבוצות. הפונקציה מחזירה את הערך מטיפוס statustype כמפורט בטבלה שלהלן: אם teamname לא מופיע ברשימת הקבוצות. אם teamname מופיע ברשימת הקבוצות. MISSING_RECORD SUCCESS בפונקציה חסרים חמישה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (5), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. המשך בעמוד 14

14 statustype deleteteam(char teamname[]) statustype status = SUCCESS; int i; teamptr t,s; t = (1) ; if (t==null) status = MISSING_RECORD; else if( (2) ) for(i=0;i < t->num;i++) (3) = NULL; ראש רשימה// teams) if (t == teams = t->next; else s = teams; while(s->next!= t) s = s->next; (4) ; (5) ; return status; המשך בעמוד 15

15 ה. לפניך פונקציה שכותרתה: statustype joinplayertoteam(long playerid,char team[]) הפונקציה מקבלת את מספר הזהות של שחקן -,playerid ואת שם הקבוצה. team אם השחקן מופיע ברשימת השחקנים והנו שחקן חופשי והקבוצה team מופיעה ברשימת הקבוצות, אזי הפונקציה מוסיפה את השחקן הזה לקבוצה ומחזירה את הערך. SUCCESS אם לא היא מחזירה את הערך.MISSING_RECORD הפונקציה מחזירה את הערך מטיפוס, statustype כמפורט בטבלה שלהלן: במקרה של הצלחה. בכל מקרה אחר. SUCCESS MISSING_RECORD בפונקציה חסרים שבעה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים )1 ) )7 (, בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. המשך בעמוד 16

16 statustype joinplayertoteam(long playerid,char team[]) statustype status = SUCCESS; playerptr p; teamptr t; p = findplayer(playerid); t = findteam(team); if((p==null) (t ==NULL)) status = MISSING_RECORD; else if ( (1) ) status = MISSING_RECORD; else p->tmptr = (2) ; if(t->num == 0) (t->plarray) = realloc( (3),sizeof(playerPtr)); (4) = p; t->num = 1; else t -> plarray = realloc ( (5),( (6) ) *sizeof(playerptr)); (7) = p; t -> num = t->num + 1;; return status; המשך בעמוד 17

17 ו. מטרתנו היא לכתוב פונקציה רקורסיבית בשם: teamptr mysort(teamptr head,int(*compare)(teamptr p,teamptr q)) הפונקציה מקבלת את, head שהנו מצביע לראש רשימת הקבוצות, ואת פונקציות ההשוואה.compare תפקידה של הפונקציה הוא למיין בסדר עולה את רשימת הקבוצות באופנים שונים. המיון יתבצע פעם לפי שם הקבוצה, פעם לפי מספר השחקנים בקבוצה ופעם לפי מפתח אחר. ניתן לזמן את הפונקציה הזו באופנים שונים, כדלהלן: אפשרות 1: מיון קבוצות לפי שמות )מחרוזות(. הזימון לפונקציה ייראה כך: mysort(teams,comparenames) אפשרות 2: מיון קבוצות לפי מספר השחקנים בקבוצה )מספרים(. הזימון לפונקציה ייראה כך: להלן מימוש של פונקציות ההשוואה שבהן תשתמש הפונקציה. mysort mysort(teams,comparesizes) int comparenames(teamptr p, teamptr q) return strcmp(p -> teamname,q->teamname); int comparesizes(teamptr p,teamptr q) if(p -> num == q -> num) return 0; else if (p -> num < q -> num) return -1; else return 1; המשך בעמוד 18

18 לפניך מימוש הפונקציה הרקורסיבית : mysort בפונקציה חסרים ארבעה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (4), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. teamptr mysort(teamptr head,int(*compare)(teamptr p,teamptr q)) teamptr t,s; t=head ; if ((t==null) (t->next == NULL)) return head ; t = (1) ; if (compare(head,t) < 0) (2) ; else s = head; head = t; while(t->next) if(compare(s,t->next) < 0) s->next = (3) ; (3) = s; break; t = t->next; מקרה: הכנסה לסוף הרשימה// NULL) if (t->next == t->next = s; (4) ; return head; המשך בעמוד 19

19 שאלה - 2 שאלת חובה )10 נקודות(. להלן תכנית בשפת C. הנח כי הטיפוס int מיוצג באמצעות ארבעה בתים, הטיפוס char מיוצג באמצעות בית אחד, וכתובת של משתנה מיוצגת באמצעות ארבעה בתים. #include <stdio.h> void f1(struct St1 st1); struct St1 int ptrint; char *ptrchar; struct St1 *pst1; ; int arrint[10] = 1,2,3,4,5,6,7,8,9,10; char *arrchar[5] = hh, jj, kk, zz, xx ; המשך התכנית בעמוד הבא // המשך בעמוד 20

20 int main() struct St1 st1arr[3] = *arrint,arrchar[3],st1arr+1, (arrint[2]),*(arrchar+2),st1arr, *&arrint[7],*arrchar,st1arr+2 ; struct St1 *pst1arr[3] = st1arr, st1arr+1, st1arr+2; struct St1 **ppst1arr = pst1arr; printf( size=%d\n, sizeof(arrchar)); printf( size=%d\n, sizeof(&st1arr)); printf( size=%d\n, sizeof(st1arr)); printf( size=%d\n, sizeof(ppst1arr)); printf( *****************\n ); printf( %c \n, (*(**pst1arr).ptrchar)); printf( %d \n, (pst1arr[2])->ptrint); printf( %s \n, ((++(*ppst1arr))->ptrchar)); printf( %d \n, ((*ppst1arr)+++ 1)->pSt1->ptrInt); ppst1arr = pst1arr; f1(**ppst1arr); printf( %d \n, (*ppst1arr)->ptrint); f1(**ppst1arr); getchar(); return 0; void f1(struct St1 st1) static int num=5; st1.ptrint = ++num; printf( num=%d \n, num); רשום במחברתך את הפלט המדויק של התכנית. המשך בעמוד 21

21 פרק שני )15 נקודות( ענה על אחת מבין השאלות 3 4 )לכל שאלה 15 נקודות(. שאלה 3 לפניך שלושה סעיפים שאינם תלויים זה בזה. ענה על כולם. א. לפניך פונקציה שכותרתה: n). char* func(unsigned הפונקציה מחזירה מערך דינמי של n תווים בסדר הפוך, כך שניתן יהיה להדפיס אותו כמחרוזת. גודל המערך יהיה רק לפי הנדרש בדיוק. )אם המספר המקורי מסתיים באפסים, אז המחרוזת תכיל גם אותם בהתחלה.( הנח שהמספר n גדול מ 0. דוגמה לשימוש בפונקציה: void main() char *p = func(123456); printf("%s\n",p); // (654321) free(p); בפונקציה חסרים חמישה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (5), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. הכנסת הספרות של המספר מימין לשמאל, כלומר החל בספרת האחדות שבצד ימין אל המערך הדינמי משמאל לימין, כמקובל, הופכת את תווי המספר. char* func(unsigned n) unsigned size=1; char *str = NULL; while(n) str= (1) ; if(!str) printf ("\nnot enough memory!");exit(1); הכנסת הספרה לפי ערך האסקי שלה// str[ (2) ]= (3) ; n/=10; (4) ; return (5) ; המשך בעמוד 22

22 ב. לפניך תכנית בשפת. C #include <stdio.h> #include <ctype.h> #include <string.h> int strfunc(char *s,char *t) int i; int result = 0; int s_length; int t_length; char temp[30]; char *temp_p; s_length = strlen(s); t_length = strlen(t); if(t_length <= s_length) for(i=0;i<(s_length - t_length+1)&&!result;i++) strcpy(temp,s); temp_p =temp+i; temp[t_length+i] = \0; if(strcmp(temp_p,t)==0) result = 1; return result; int main(void) char s1[30] = question number e in c exam ; char s2[30] = n n ; char s3[30] = exam ; char s4[30]= inc ; if(strfunc(s1,s2)) printf( Yes\n ); else printf ( No\n ); if(strfunc(s1,s3)) printf( Yes\n ); else printf ( No\n ); if(strfunc(s1,s4)) printf( Yes\n ); else printf ( No\n ); return 0; רשום במחברתך את הפלט המדויק של התכנית הנתונה. המשך בעמוד 23

23 ג. נתונים המבנים הבאים: typedef struct Driver; char name[len]; int id; שם הנהג// מספר הרישיון של הנהג// נהג// typedef struct מחיר המכונית// price; int Driver d; Car; מכונית// נתונים ב main שני מערכים של מכוניות. נתון שכל אחד מהמערכים ממוין בסדר עולה לפי מספר הרישיון של הנהג. לפניך פונקציה: n2), Car ** func(const Car A[], int n1, const Car B[], int כאשר - n1 גודל המערך - n2. A גודל המערך. B הפונקציה יוצרת מערך דינמי חדש של מצביעים למכוניות, כך שכל מצביע יצביע למבנה חדש של מכונית אחרת. במערך החדש יופיעו כל המכוניות משני המערכים, והוא יהיה ממוין בסדר עולה לפי מספרי הרישיון של נהגי המכוניות. אילוצים: אין להשתמש במערך עזר. אין לשנות את המערכים המקוריים. אסור להשתמש בלולאות מקוננות, כלומר לא תופיע לולאה בתוך לולאה. )לא יתקבלו פתרונות עם לולאות מקוננות.( לאור האילוצים האלו להלן הפונקציה: בפונקציה זו חסרים שבעה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (7), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. המשך בעמוד 24

24 Car **func(const Car A[],int n1,const Car B[],int n2) int i=0,j=0,k=0,t; מקצה את המצביעים// ; (1) =C** Car if(!c) printf("not enough memory!");exit(1); for(t=0;t<n1+n2;t++) מקצה את המבנים החדשים// C[t]= (2) ; if(!c[t]) printf ("Not enough memory!");exit(2); סורק את שני המערכים// while( (3) ) if(a[i].d.id<b[j].d.id ) (4) ; else if (A[i].d.id>B[i].d.id) (5) ; else (4) ; (5) ; while( (6) ) while( (7) ) *C[k++]=A[i++]; *C[k++]=B[j++]; return C; המשך בעמוד 25

25 שאלה 4 לפניך הגדרות: מטריצה T מסדר M N תיקרא מטריצת טפליץ אם היא מקיימת את התנאי הזה: לכל i ו j כאשר: 1 M j N 1, 1 i 1 מתקיים: 1] [j. T [i] [j] = T [i 1] דוגמה :1 להלן מטריצת טפליץ T בגודל 5 4 : למטריצת טפליץ מסדר M N ייתכנו לכל היותר 1 N M + ערכים שונים, ולכן ניתן לאחסן את מטריצת טפליץ במערך חד ממדי בגודל 1 N M + והוא ייקרא וקטור טפליץ. וקטור טפליץ יכיל את איברי השורה ה 0 של מטריצת טפליץ )בסדר שבו הם מופיעים בשורה זו( ואחריהן כל איברי העמודה ה 0 )בסדר שבו הם מופיעים בעמודה זו(, חוץ מאשר את האיבר הראשון שבעמודה זו. דוגמה :2 בעבור מטריצת טפליץ T שבדוגמה, 1 וקטור טפליץ הנו: הערה: בסעיפים א' ג' הנח שמטריצת טפליץ היא מסדר. M N להלן הגדרות והכרזות בשפת : C #define M 4 #define N 5 המשך בעמוד 26

26 א. לפניך פונקציה שכותרתה [( V] void convertmatrix (int T[ ][N], int אשר מקבלת שני פרמטרים, T ו V, כאשר T הנו מטריצת טפליץ. הפונקציה משכנת את וקטור טפליץ של T במערך חד ממדי V. בפונקציה חסרים שלושה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (3), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. void convertmatrix(int T[ ][N],int V[ ]) int i,j; for(i=0;i < N;i++) V[i]= (1) ; for (j= (2) ;j< M;j++) (3) = T[j][0]; ב. המטריצה המוחלפת של מטריצה A מסדר M N היא מטריצה המסומנת ב A T )מסדר N( M אשר מתקבלת כדלקמן: שורה 0 של A הופכת להיות עמודה 0 ב. A T שורה 1 של A הופכת להיות עמודה 1 ב. A T : : וכן הלאה. כלומר, לכל i < M 0 השורה ה i של A הופכת להיות עמודה i במטריצה. A T המשך בעמוד 27

27 דוגמה 3: בעבור המטריצה T שבדוגמה 1 המטריצה המוחלפת שלה היא: שים לב: המטריצה המוחלפת של מטריצת טפליץ היא גם מטריצת טפליץ. לפניך פונקציה שכותרתה [( ] VT void transpose Matrix (int V[ ], int אשר מקבלת שני פרמטרים V ו VT, כאשר V הוא וקטור טפליץ המייצג את המטריצה. A הפונקציה משכנת לתוך מערך חד ממדי VT את וקטור טפליץ המייצג את המטריצה, AT ללא שחזור המטריצות. ו AT A בפונקציה חסרים שלושה ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (3), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. void transposematrix(int V[ ],int VT[ ]) int i,j; VT[0]=V[0]; for (j=1;j< (1) ;j++) VT[j] = V[ (2) ]; for(i=1;i<n;i++) VT[ (3) ]= V[i]; המשך בעמוד 28

28 ג. לפניך פונקציה שכותרתה [( W] void addmatrix(int U[ ], int V[ ], int אשר מקבלת כפרמטרים שלושה מערכים חד ממדיים U, V ו W, כאשר U ו V מכילים שני וקטורי טפליץ שמייצגים שתי מטריצות טפליץ A ו B בהתאמה. הפונקציה משכנת לתוך W וקטור טפליץ המייצג מטריצה שהיא סכום המטריצות A ו B ללא שחזור המטריצות A ו B. בפונקציה חסרים שני ביטויים, המסומנים במספרים בין סוגריים עגולים. רשום במחברת הבחינה את מספרי הביטויים החסרים (1) (2), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. void addmatrix(int U[ ],int V[ ],int W[ ]) int i; for(i=0; i < (1) ;i++) (2) ; המשך בעמוד 29

29 נושא ב': שפת סף )50 נקודות( פרק שלישי )20 נקודות( ענה על שאלה 5 שאלת חובה. שאלה 5 להלן תכנית אשר מאתרת במחרוזת נתונה רצף מסוים של תווים ומחליפה אותו ברצף אחר. התכנית מבצעת את פעולת האיתור בשלושה שלבים הבאים לידי ביטוי בשלושת הקטעים א' - ג' שלהלן. DATA SEGMENT MSG DB 'DEFDEFDEDEF MSG_LEN=$-MSG WHAT_TO_REPLACE DB 'DEF REPLACE_BY DB 'ABC LEN=$-REPLACE_BY MONE DW MSG_LEN DATA ENDS SSEG SEGMENT STACK 'STACK DB 100H DUP(?) SSEG ENDS CODE SEGMENT ASSUME CS:CODE,DS:DATA המשך בעמוד 30

30 START:MOV AX,DATA MOV DS,AX PUSH DS POP ES LEA DI,MSG LEA SI,WHAT_TO_REPLACE MOV BX,DI ;============================================= AGAIN: MOV (1),[BX] CMP AL,[SI] JE (2) INC BX קטע א' ; DEC MONE JNZ AGAIN JMP SOF ;============================================= CHECK: CMP MONE,LEN JB (3) MOV CX,LEN MOV DI,BX קטע ב' ; REPE (4) JNE NEXT ;============================================= המשך בעמוד 31

31 MOV CX,LEN MOV DI,BX LEA SI,REPLACE_BY REP MOVSB קטע ג' ; MOV BX,DI LEA SI, (5) SUB MONE,LEN CMP MONE, (6) JE SOF JMP AGAIN NEXT: LEA SI,WHAT_TO_REPLACE INC BX DEC MONE JNZ AGAIN ;============================================= SOF: MOV AH,4CH CODE ENDS END START INT 21H המשך בעמוד 32

32 א. קטע א' של התכנית מחפש את התו 'D' במחרוזת. DEFDEFDEDEF אם התו 'D' נמצא, אז התכנית תעבור לביצוע קטע ב', אחרת התכנית מסתיימת. בקטע א' חסרים שני ביטויים המסומנים במספרים בין סוגריים עגולים. רשום במחברתך את מספרי הביטויים החסרים (1) (2), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. ב. קטע ב' של התכנית בודק אם תת-המחרוזת DEF נמצאת במחרוזת DEFDEFDEDEF שבכתובת. MSG אם תת המחרוזת DEF נמצאת במחרוזת, DEFDEFDEDEF אז התכנית תעבור לביצוע קטע ג', אחרת התכנית מסתיימת. בקטע ב' חסרים שני ביטויים המסומנים במספרים בין סוגריים עגולים. רשום במחברתך את מספרי הביטויים החסרים (3) (4), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. ג. קטע ג' של התכנית מחליף את המחרוזת def במחרוזת. abc בקטע ג' חסרים שני ביטויים המסומנים במספרים בין סוגריים עגולים. רשום במחברתך את מספרי הביטויים החסרים (5) (6), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. המשך בעמוד 33

33 פרק רביעי )30 נקודות( ענה על שתיים מבין השאלות 6 8 )לכל שאלה 15 נקודות(. שאלה 6 לפניך תכנית אשר מקרינה על הצג את המספר NUM בן 16 סיביות בייצוג בינארי. דוגמה: בעבור המספר 49 התכנית תציג כפלט את SSEG SEGMENT STACK 'STACK' DB 100H DUP(?) SSEG ENDS CODE SEGMENT ASSUME CS:CODE NUM DW 81H START:MOV CX, (1) MOV AH, (2) AGAIN:ROL NUM,1 PUSH NUM JNC ZERO (3) INT 21H JMP NEXT ZERO: (4) INT 21H NEXT:LOOP AGAIN SOF: MOV AH,4CH INT 21H CODE ENDS END START המשך בעמוד 34

34 א. בתכנית הנתונה חסרים ארבעה ביטויים המסומנים במספרים בין סוגריים עגולים. רשום במחברתך את מספרי הביטויים החסרים (1) (4), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. ב. אם נחליף את ההוראה NUM,1 ROL בהוראה NUM,1,SHL האם שינוי זה יכול להשפיע על הערך שיוקרן על הצג? ענה כן או לא. ג. אם נחליף את ההוראה NUM,1 ROL בהוראה NUM,1,SHL האם שינוי זה יכול להשפיע על תוכנו של? NUM ענה כן או לא. ד. הנח כי תוכנו של האוגר SP הוא: העתק למחברתך את הטבלה הבאה המייצגת אזור מסוים של מחסנית: תוכן הבית כתובת הבית לאחר ביצוע שני צעדי לולאה, רשום בטבלה את התוכן בבסיס הקסדצימלי של הבתים שכתובתם 1003H ועד )וכולל( 1000H בלבד. המשך בעמוד 35

35 שאלה 7 נתונה רשימה מקושרת לא ריקה הבנויה משני צמתים לפחות. כל צומת ברשימה מכיל את שני השדות האלה: - info שדה מידע )אינפורמציה(, שגודלו 8 ביטים, המכיל תו. - next המצביע אל הצומת הבא ברשימה, שגודלו מילה )16 ביטים(. המצביע next בצומת האחרון הוא 0. נוסף על כך נתון כי המשתנה LIST מכיל את הכתובת של הצומת הראשון ברשימה LIST a a b c a d d a המשך בעמוד 36

36 START:MOV AX,DATA MOV DS,AX MOV DI,LIST MOV BX,[DI+1] NEXT: CMP WORD PTR[BX+1],0 JE EXIT MOV BX,[BX+1] CMP WORD PTR[BX+1],0 JE EXIT MOV BX,[BX+1] MOV DI,[DI+1] JMP NEXT EXIT: MOV BX,[DI+1] MOV WORD PTR [DI+1],0 sof: MOV AH, 4CH CODE ENDS END START INT 21H לפניך קטע התכנית שלהלן: המשך בעמוד 37

37 א. הרץ ידנית את קטע התכנית על הרשימה שלהלן: LIST כתובת 1000 H כתובת 2000 H כתובת 3000 H כתובת 4000 H כתובת 5000 H כתובת 6000 H כתובת 7000 H כתובת 8000 H a a b c a d d a מעל כל צומת רשום מספר )בבסיס 16( המציין את כתובתו של הצומת. רשום במחברתך טבלת מעקב בעבור האוגרים BX ו DI עד שהתכנית מגיעה לתווית. SOF ב. הרץ ידנית את קטע התכנית על הרשימה שלהלן: LIST כתובת 1000 H כתובת 2000 H כתובת 3000 H כתובת 4000 H כתובת 5000 H כתובת 6000 H כתובת 7000 H a a b c a d d מעל כל צומת רשום מספר )בבסיס 16( המציין את כתובתו של הצומת. רשום במחברתך טבלת מעקב בעבור טבלת מעקב בעבור האוגרים BX ו DI עד שהתכנית מגיעה לתווית. SOF ג. אם נחליף את ההוראה MOV DI,LIST בהוראה, LEA DI,LIST האם ישתנו ביצועי התכנית? ענה כן או לא. המשך בעמוד 38

38 שאלה 8 בהינתן מספר שלם וחיובי ניתן ליצור עבורו סדרה x 1 x... n באופן הזה: בסדרה זו קיים n שעבורו = 1 n. x xi xi+ = 1 2 3xi + 1 x i זוגי x i אי זוגי הערות: סדרה כזו תמיד מסתיימת במספר. 1 n הוא מספר האיברים בסדרה. דוגמה: עבור המספר 7 נקבל: ובעבור המספר 20 נקבל: לפניך תכנית רקורסיבית המקבלת מספר שלם חיובי שהוא המספר הראשון בסדרה. התכנית יוצרת סדרה, כמתואר לעיל, ומציבה במערך ARR את כל המספרים המתקבלים בסדרה זו מן הסוף להתחלה. עבור המספר 7 המערך ARR יכיל את המספרים האלה )קרא משמאל לימין(: 1, 2, 4, 8, 16, 5, 10, 20, 40, 13, 26, 52, 17, 34, 11, 22 הנחת יסוד: גודלו של המערך ARR מספיק לאחסון המספרים המתקבלים בסדרה. המשך בעמוד 38

39 התכנית שלהלן נעזרת בשגרה רקורסיבית בשם. SIDRA בשגרה זו חסרים שבעה ביטויים המסומנים במספרים בין סוגריים עגולים. רשום במחברתך את מספרי הביטויים החסרים (1) (7), בסדר עולה, וכתוב ליד כל מספר את הביטוי החסר שהוא מייצג. SSEG SEGMENT STACK 'STACK DB 100H DUP(?) SSEG ENDS CODE SEGMENT ASSUME CS:CODE NUM DW 5 ARR DW 100 DUP(0) START: PUSH CS POP DS PUSH NUM LEA BX,ARR CALL SIDRA SOF: MOV AH,4CH INT 21H המשך התכנית בעמוד הבא // המשך בעמוד 40

40 SIDRA: PUSH BP MOV BP,SP MOV AX,[BP+4] (1) JE SI_EXIT TEST AX,1 JNZ SI_ODD (2) AX,1 JMP (3) SI_ODD: ADD AX,AX ADD AX, (4) ADD AX,1 SI_NEXT: (5) CALL SIDRA SI_EXIT: MOV AX,[BP+4] MOV (6),AX INC BX INC BX POP BP RET (7) CODE ENDS END START בהצלחה! זכות היוצרים שמורה למדינת ישראל. אין להעתיק או לפרסם אלא ברשות משרד החינוך.